package org.c41.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import org.c41.system.ImpossibleException;

public final class Modifiers {

	private Modifiers(){
		throw new ImpossibleException();
	}
	
	private final static String[][] array_map ={
		{"boolean","Z"},
		{"byte","B"},
		{"char","C"},
		{"double","D"},
		{"float","F"},
		{"int","I"},
		{"long","J"},
		{"short","S"}
	};

	public static String castToBasicName(String str){
		int n = str.indexOf("[]");
		if(n == -1){
			return str;
		}
		StringBuilder builder = new StringBuilder();
		String type = str.substring(0,n);
		for(String[] map:array_map){
			if(map[0].equals(type)){
				for(int i=n;i<str.length();i+=2){
					builder.append("[");
				}
				builder.append(map[1]);
				return builder.toString();
			}
		}
		for(int i=n;i<str.length();i+=2){
			builder.append("[");
		}
		builder.append("L").append(type).append(";");
		return builder.toString();
	}

	public static String castToNormalName(String str){
		int n = str.lastIndexOf("[");
		if(n == -1){
			return str;
		}
		StringBuilder builder = new StringBuilder();
		String type = str.substring(n+1);
		for(String[] map:array_map){
			if(map[1].equals(type)){
				builder.append(map[0]);
				for(int i=0;i<=n;i++){
					builder.append("[]");
				}
				return builder.toString();
			}
		}
		builder.append(str.substring(n+2,str.length()-1));
		for(int i=0;i<=n;i++){
			builder.append("[]");
		}
		return builder.toString();
	}

	public static boolean isFinal(Class<?> cl){
		return Modifier.isFinal(cl.getModifiers());
	}

	public static boolean isPrivate(Class<?> cl){
		return Modifier.isPrivate(cl.getModifiers());
	}

	public static boolean isProtected(Class<?> cl){
		return Modifier.isProtected(cl.getModifiers());
	}

	public static boolean isPublic(Class<?> cl){
		return Modifier.isPublic(cl.getModifiers());
	}

	public static boolean isDefault(Class<?> cl){
		return !isPublic(cl)&&!isProtected(cl)&&!isPrivate(cl);
	}

	public static boolean isStatic(Class<?> cl){
		return Modifier.isStatic(cl.getModifiers());
	}

	public static boolean isStrictfp(Class<?> cl){
		return Modifier.isStrict(cl.getModifiers());
	}

	public static boolean isAbstract(Class<?> cl){
		return Modifier.isAbstract(cl.getModifiers());
	}

	public static boolean isAbstract(Method method){
		return Modifier.isAbstract(method.getModifiers());
	}

	public static boolean isFinal(Method method){
		return Modifier.isFinal(method.getModifiers());
	}

	public static boolean isFinal(Field field){
		return Modifier.isFinal(field.getModifiers());
	}

	public static boolean isNative(Method method){
		return Modifier.isNative(method.getModifiers());
	}

	public static boolean isPrivate(Method method){
		return Modifier.isPrivate(method.getModifiers());
	}

	public static boolean isPrivate(Constructor<?> constructor){
		return Modifier.isPrivate(constructor.getModifiers());
	}

	public static boolean isPrivate(Field field){
		return Modifier.isPrivate(field.getModifiers());
	}

	public static boolean isProtected(Method method){
		return Modifier.isProtected(method.getModifiers());
	}

	public static boolean isProtected(Constructor<?> constructor){
		return Modifier.isProtected(constructor.getModifiers());
	}

	public static boolean isProtected(Field field){
		return Modifier.isProtected(field.getModifiers());
	}

	public static boolean isPublic(Method method){
		return Modifier.isPublic(method.getModifiers());
	}

	public static boolean isPublic(Constructor<?> constructor){
		return Modifier.isPublic(constructor.getModifiers());
	}

	public static boolean isPublic(Field field){
		return Modifier.isPublic(field.getModifiers());
	}

	public static boolean isDefault(Method method){
		return !isPublic(method)&&!isProtected(method)&&!isPrivate(method);
	}

	public static boolean isDefault(Constructor<?> constructor){
		return !isPublic(constructor)&&!isProtected(constructor)&&!isPrivate(constructor);
	}

	public static boolean isDefault(Field field){
		return !isPublic(field)&&!isProtected(field)&&!isPrivate(field);
	}

	public static boolean isStatic(Method method){
		return Modifier.isStatic(method.getModifiers());
	}

	public static boolean isStatic(Field field){
		return Modifier.isStatic(field.getModifiers());
	}

	public static boolean isStrictfp(Method method){
		return Modifier.isStrict(method.getModifiers());
	}

	public static boolean isStrictfp(Constructor<?> constructor){
		return Modifier.isStrict(constructor.getModifiers());
	}

	public static boolean isSynchronized(Method method){
		return Modifier.isSynchronized(method.getModifiers());
	}

	public static boolean isTransient(Field field){
		return Modifier.isTransient(field.getModifiers());
	}

	public static boolean isVolatile(Field field){
		return Modifier.isVolatile(field.getModifiers());
	}

}
